home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 8: LINUX Games / Linux Cubed Series 8 - LINUX Games.iso / games / x11 / rpg / crossfir.92 / crossfir / crossfire-0.92.5 / server / alchemy.c next >
C/C++ Source or Header  |  1996-07-24  |  18KB  |  552 lines
  1.  
  2. /* March 96 - Laid down original code. -b.t. thomas@astro.psu.edu */
  3.  
  4. #include <global.h>
  5. #include <object.h>
  6. #ifndef __CEXTRACT__
  7. #include <sproto.h>
  8. #endif
  9. #include <skills.h>
  10. #include <spells.h>
  11.  
  12. /* define this for some helpful debuging information */
  13. #define ALCHEMY_DEBUG
  14.  
  15. /* define this for loads of (marginal) debuging information */
  16. #define EXTREME_ALCHEMY_DEBUG
  17.  
  18. static char *cauldron_effect [] = { 
  19.  "vibrates briefly",
  20.  "produces a cloud of steam",
  21.  "emits bright flames",
  22.  "pours forth heavy black smoke",
  23.  "emits sparks",
  24.  "shoots out small flames",
  25.  "whines painfully",
  26.  "hiccups loudly",
  27.  "wheezes",
  28.  "burps",
  29.  "shakes",
  30.  "rattles",
  31.  "makes chugging sounds",
  32.  "smokes heavily for a while"
  33. }; 
  34.  
  35.  
  36. /* cauldron_sound() - returns a random selection from cauldron_effect[] */
  37.  
  38. char * cauldron_sound ( void ) {
  39.   int size=sizeof(cauldron_effect)/sizeof(char *);
  40.  
  41.   return cauldron_effect[RANDOM()%size]; 
  42. }
  43.  
  44. /* attempt_do_alchemy() - Main part of the ALCHEMY code. From this we call fctns
  45.  * that take a look at the contents of the 'cauldron' and, using these ingredients, 
  46.  * we construct an integer formula value which is referenced (randomly) against a 
  47.  * formula list (the formula list chosen is based on the # contents of the cauldron).
  48.  *
  49.  * If we get a match between the recipe indicated in cauldron contents and a 
  50.  * randomly chosen one, an item is created and experience awarded. Otherwise 
  51.  * various failure effects are possible (getting worse and worse w/ # cauldron 
  52.  * ingredients). Note that the 'item' to be made can be *anything* listed on 
  53.  * the artifacts list in lib/artifacts which has a recipe listed in lib/formulae.
  54.  *
  55.  * To those wondering why I am using the funky formula index method:
  56.  *   1) I want to match recipe to ingredients regardless of ordering.
  57.  *   2) I want a fast search for the 'right' recipe.
  58.  * 
  59.  * Note: it is just possible that a totally different combination of
  60.  * ingredients will result in a match with a given recipe. This is not a bug!
  61.  * There is no good reason (in my mind) why alchemical processes have to be
  62.  * unique -- such a 'feature' is one reason why players might want to experiment
  63.  * around. :)
  64.  * -b.t.
  65.  */
  66.  
  67. void attempt_do_alchemy(object *caster, object *cauldron) {
  68.   recipelist *fl;
  69.   recipe *rp=NULL;
  70.   int numb,i;
  71.   int formula=0,danger=calc_alch_danger(caster,cauldron);
  72.  
  73.      if(caster->type!=PLAYER) return; /* only players for now */ 
  74.  
  75.       /* if no ingredients, no formula! lets forget it */
  76.      if(!(formula=content_recipe_value(cauldron))) return;
  77.  
  78.      numb=numb_ob_inside(cauldron);
  79.      if((fl=get_formulalist(numb))) {
  80.         int j,ability=SK_level(caster)+cauldron->magic;
  81.  
  82. #ifdef ALCHEMY_DEBUG
  83.     LOG(llevDebug,"Got alchemy ability: %d\n",ability);
  84. #endif
  85.  
  86.         if(QUERY_FLAG(caster,FLAG_WIZ)) { 
  87.         rp=fl->items;
  88.         while(rp && rp->index!=formula) {
  89. #ifdef EXTREME_ALCHEMY_DEBUG
  90.         LOG(llevDebug," grabbed list %d formula: %s of %s (%d)\n",numb,
  91.            rp->arch_name,rp->title,rp->index);
  92. #endif
  93.             rp=rp->next;
  94.         }
  95.         if(rp) {
  96. #ifdef ALCHEMY_DEBUG
  97.         if(strcmp(rp->title,"NONE"))
  98.             LOG(llevDebug,"WIZ got formula: %s of %s\n",
  99.             rp->arch_name,rp->title);
  100.         else 
  101.             LOG(llevDebug,"WIZ got formula: %s\n",rp->arch_name);
  102. #endif
  103.         attempt_recipe(caster,cauldron,rp);
  104.         } else LOG(llevDebug,"WIZ couldnt find formula for ingredients.\n"); 
  105.         return;
  106.     } 
  107.  
  108.     /* player loop--trying to match random recipe */ 
  109.         for(i=ability;i>0;i--) { 
  110.             rp=fl->items;
  111.  
  112.         if(fl->number>1) /* select a random recipe */
  113.                 for(j=RANDOM()%fl->number;j>1;j--) rp=rp->next;
  114.  
  115.             if(rp->index==formula) { /* we matched a recipe */
  116.             if(!(attempt_recipe(caster,cauldron,rp))) 
  117.                break;
  118.             else return;
  119.             }
  120.     }
  121.      } 
  122.  
  123.       /* if we get here, we failed!! */
  124.      alchemy_failure_effect(caster,cauldron,rp,danger);
  125. }
  126.  
  127. /* content_recipe_value()- recipe value of the entire contents of a container. */
  128.  
  129. int content_recipe_value (object *op) {
  130.   char name[MAX_BUF];
  131.   object *tmp=op->inv;
  132.   int tval=0,formula=0;
  133.  
  134.     while(tmp) {
  135.     tval=0;
  136.         strcpy(name,tmp->name);
  137.         if(tmp->title) sprintf(name,"%s %s",tmp->name,tmp->title);
  138.         tval = (strtoint(name) * (tmp->nrof?tmp->nrof:1));
  139. #ifdef ALCHEMY_DEBUG
  140.         LOG(llevDebug,"Got ingredient %d %s(%d)\n",tmp->nrof?tmp->nrof:1,
  141.         name,tval);
  142. #endif   
  143.     formula += tval;
  144.         tmp=tmp->below;
  145.     }   
  146. #ifdef ALCHEMY_DEBUG
  147.     LOG(llevDebug," FORMULA value=%d\n",formula);
  148. #endif
  149.     return formula;
  150. }
  151.  
  152. /* numb_ob_inside() */
  153.  
  154. int numb_ob_inside (object *op) {
  155.   object *tmp=op->inv;
  156.   int number=0,o_number=0;
  157.  
  158.     while(tmp) {
  159.         if(tmp->nrof) number += tmp->nrof;
  160.         else number++;
  161.     o_number++;
  162.         tmp=tmp->below;
  163.     }   
  164. #ifdef ALCHEMY_DEBUG
  165.     LOG(llevDebug,"numb_ob_inside(%s): found %d ingredients\n",op->name,o_number);
  166. #endif 
  167.     return o_number;
  168. }
  169.  
  170. /* attempt_recipe() - essentially a wrapper for make_item_from_recipe() and 
  171.  * insert_ob_in_ob. If the caster has some alchemy skill, then they might
  172.  * gain some exp from (successfull) fabrication of the product. 
  173.  */ 
  174.  
  175. object * attempt_recipe(object *caster, object *cauldron, recipe *rp) { 
  176.   object *item=NULL;   
  177.  
  178.     if((item=make_item_from_recipe(cauldron,rp))!=NULL) { 
  179.        remove_contents(cauldron->inv,item);
  180.        adjust_product(item,caster); /* adj lvl, nrof on caster level */ 
  181.        if(!item->env && (item=insert_ob_in_ob(item,cauldron))==NULL) { 
  182.                 new_draw_info_format(NDI_UNIQUE, 0,caster, 
  183.                    "Your spell causes the %s to explode!",cauldron->name);
  184.                 /* kaboom_cauldron(); */ 
  185.        } else {
  186.         if(find_skill(caster,SK_ALCHEMY)!=NULL) {
  187.                 change_skill(caster,SK_ALCHEMY);
  188.              add_exp(caster,calc_skill_exp(caster,item));
  189.             item->stats.exp=0; /* so when skill id, less xp awarded */
  190.             }
  191.                 new_draw_info_format(NDI_UNIQUE, 0,caster, 
  192.                         "The %s %s.",cauldron->name,cauldron_sound());
  193.        }   
  194.     }    
  195.  
  196.     return item; 
  197. } 
  198.  
  199. /* table of alchemical probability (1-100). Used by adjust_product. */
  200. static int alprob [] = { 10, 25, 35, 45, 50, 55, 65, 68, 70, 73, 75, 76, 77, 78, 79};
  201.  
  202. /* adjust_product() - we adjust the nrof, exp and level of the final product, based
  203.  * on the item's default parameters, and the relevant caster skill level. */
  204.  
  205. void adjust_product(object *item,object *caster) {
  206.    object *skill=NULL;
  207.    int lvl=1,nrof=1,maxnrof;
  208.  
  209.    /* if the caster has alchemy (mental) exp use that level */
  210.    if((skill=find_skill(caster,SK_ALCHEMY)) && skill->exp_obj) 
  211.     lvl = skill->exp_obj->level;
  212.  
  213.    maxnrof = lvl/5;
  214.    if(item->nrof) {
  215.      int prob = maxnrof>(sizeof(alprob)/sizeof(int)) ? 80 : alprob[maxnrof];
  216.      while (maxnrof--)
  217.          if(RANDOM()%100<prob) nrof++;
  218.      item->nrof=nrof;
  219.    }
  220.  
  221.    /* item exp. This will be used later for experience calculation */
  222.    item->stats.exp += lvl*lvl*nrof;
  223.  
  224.    /* item->level = (lvl+item->level)/2; avg between default and caster levels */
  225.    
  226. }
  227.  
  228. /* make_item_from_recipe()- using a list of items and a recipe to make an artifact. */
  229.  
  230. object * make_item_from_recipe(object *cauldron, recipe *rp) {
  231.   artifact *art=NULL;
  232.   object *item=NULL;
  233.  
  234.     if(rp==NULL) return (object *) NULL;
  235.  
  236.     /* Find the appropriate object to transform...*/
  237.     if((item=find_transmution_ob(cauldron->inv,rp))==NULL) {
  238.         LOG(llevDebug,"make_alchemy_item(): failed to create alchemical object.\n");
  239.         return (object *) NULL;
  240.     }
  241.  
  242.     /* Find the appropriate artifact template...*/
  243.     if(strcmp(rp->title,"NONE")) { 
  244.         if((art=locate_recipe_artifact(rp))==NULL) {
  245.             LOG(llevError,"make_alchemy_item(): failed to locate recipe artifact.\n");
  246.             LOG(llevDebug,"  --requested recipe: %s of %s.\n",rp->arch_name,rp->title);
  247.             return (object *) NULL;
  248.     }
  249.         give_artifact_abilities(item,art->item);
  250.     }
  251.  
  252.     if(QUERY_FLAG(cauldron,FLAG_CURSED)) SET_FLAG(item,FLAG_CURSED);
  253.     if(QUERY_FLAG(cauldron,FLAG_DAMNED)) SET_FLAG(item,FLAG_DAMNED);
  254.  
  255.     return item;
  256. }
  257.  
  258.  
  259. /* find_transmution_ob() - looks through the ingredient list, if we find a
  260.  * suitable object in it - we will use that to make the requested artifact.
  261.  * Otherwise the code returns a 'generic' item. -b.t.
  262.  */
  263.  
  264. object * find_transmution_ob ( object *first_ingred, recipe *rp) {
  265.    object *item=NULL;
  266.  
  267.    if(rp->transmute) /* look for matching ingredient/prod archs */ 
  268.         for(item=first_ingred;item;item=item->below)
  269.             if(!strcmp(item->arch->name,rp->arch_name)) break; 
  270.  
  271.     /* failed, create a fresh object. Note no nrof>1 because that would
  272.      * allow players to create massive amounts of artifacts easily */
  273.    if(!item||item->nrof>1)
  274.         item=get_archetype(rp->arch_name);
  275.  
  276. #ifdef ALCHEMY_DEBUG
  277.    LOG(llevDebug,"recipe calls for%stransmution.\n",rp->transmute?" ":" no ");
  278.    if(strcmp(item->arch->name,rp->arch_name))
  279.        LOG(llevDebug,"WARNING: recipe calls for arch: %s\n",rp->arch_name);
  280.    LOG(llevDebug," find_transmutable_ob(): returns arch %s(sp:%d)\n",
  281.         item->arch->name,item->stats.sp);
  282. #endif
  283.  
  284.    return item;
  285. }
  286.  
  287.  
  288. /* alchemy_failure_effect - Ouch. We didnt get the formula we wanted.
  289.  * This fctn simulates the backfire effects--worse effects as the level
  290.  * increases. If SPELL_FAILURE_EFFECTS is defined some really evil things
  291.  * can happen to the would be alchemist. This table probably needs some
  292.  * adjustment for playbalance. -b.t.
  293.  */
  294.  
  295. void alchemy_failure_effect(object *op,object *cauldron,recipe *rp,int danger) {
  296.   int level=0;
  297.  
  298.   if(!op || !cauldron) return; 
  299.  
  300.   if(danger>1) level=RANDOM()%danger+1;
  301.  
  302. #ifdef ALCHEMY_DEBUG
  303.   LOG(llevDebug,"Alchemy_failure_effect(): using level=%d\n",level); 
  304. #endif
  305.  
  306.   /* possible outcomes based on level */
  307.   if(level>10&&level<25) {                   /* INGREDIENTS USED/SLAGGED */
  308.       object *item=NULL;
  309.  
  310.       if(RANDOM()%3) {  /* slag created */
  311.         object *tmp=cauldron->inv;
  312.         int weight=0;
  313.     uint16 material=M_STONE;
  314.  
  315.         while(tmp) { /* slag has coadded ingredient properties */
  316.        weight+=tmp->weight; 
  317.        if(!(material&tmp->material)) 
  318.         material=material|tmp->material; 
  319.        tmp=tmp->below;
  320.         }
  321.         tmp = get_archetype("rock");
  322.         tmp->weight=weight;
  323.         tmp->value=0;
  324.     tmp->material=material;
  325.     free_string(tmp->name);
  326.     tmp->name=add_string("slag");
  327.         item=insert_ob_in_ob(tmp,cauldron);
  328.     CLEAR_FLAG(tmp,FLAG_CAN_ROLL);
  329.     CLEAR_FLAG(tmp,FLAG_NO_PICK);
  330.     CLEAR_FLAG(tmp,FLAG_NO_PASS);
  331.       } 
  332.       remove_contents(cauldron->inv,item);
  333.       new_draw_info_format(NDI_UNIQUE,0,op, 
  334.     "The %s %s.",cauldron->name,cauldron_sound());
  335.       return;
  336.   } else if (level< 40) {                    /* MAKE TAINTED ITEM */
  337.       object *tmp=NULL;
  338.  
  339.       if (!rp) 
  340.        if((rp=get_random_recipe((recipelist *) NULL))==NULL) 
  341.               return;
  342.  
  343.       if((tmp=attempt_recipe(op,cauldron,rp))) { 
  344.            if(!QUERY_FLAG(tmp,FLAG_CURSED)) /* curse it */
  345.            SET_FLAG(tmp,FLAG_CURSED);
  346.  
  347.         /* special stuff for consumables */
  348.            if(tmp->type==POTION||tmp->type==FOOD) {
  349.                 if(tmp->stats.sp&&RANDOM()%2) /* drains magic */
  350.             tmp->stats.sp = SP_REGENERATE_SPELLPOINTS;
  351.                 if(RANDOM()%2) {         /* poisonous */
  352.             tmp->type=FOOD; 
  353.             tmp->stats.hp=RANDOM()%150;
  354.             }
  355.            }
  356.  
  357.                /* change stats downward */
  358.            if(tmp->type!=FOOD) 
  359.           do {
  360.                change_attr_value(&tmp->stats,RANDOM()%6,-1*RANDOM()%3);
  361.              } while (RANDOM()%3);
  362.       }  
  363.       return;
  364.  
  365.   } if(level==40) {                          /* MAKE RANDOM RECIPE */
  366.       recipelist *fl;
  367.       int numb=numb_ob_inside(cauldron);
  368.  
  369.       fl=get_formulalist(numb);
  370.       if(fl &&(rp=get_random_recipe(fl)))
  371.           (void) attempt_recipe(op,cauldron,rp);
  372.       else 
  373.       alchemy_failure_effect(op,cauldron,rp,level-1);
  374.       return;
  375.  
  376.   } else if (level<45) {                    /* INFURIATE NPC's */
  377.        /* this is kind of kludgy I know...*/
  378.       cauldron->enemy=op;
  379.       npc_call_help(cauldron);
  380.       cauldron->enemy=NULL;
  381.  
  382.       alchemy_failure_effect(op,cauldron,rp,level-5);
  383.       return;
  384.  
  385.   }
  386. /* #ifdef SPELL_FAILURE_EFFECTS */ 
  387.    else if (level<50) {                        /* MINOR EXPLOSION/FIREBALL */
  388.       object *tmp;
  389.       remove_contents(cauldron->inv,NULL);
  390.       switch(RANDOM()%3) {
  391.     case 0: 
  392.            tmp=get_archetype("bomb");
  393.          tmp->stats.dam=RANDOM()%level+1;
  394.          tmp->stats.hp=RANDOM()%level+1;
  395.        break;    
  396.              new_draw_info_format(NDI_UNIQUE,0,op,"The %s creates a bomb!",
  397.         cauldron->name);
  398.        break; 
  399.     default:
  400.            tmp=get_archetype("fireball");
  401.          tmp->stats.dam=(RANDOM()%level+1)/5+1;
  402.          tmp->stats.hp=(RANDOM()%level+1)/10+2;
  403.              new_draw_info_format(NDI_UNIQUE,0,op,"The %s erupts in flame!",
  404.         cauldron->name);
  405.        break;
  406.       }
  407.       tmp->x=cauldron->x,tmp->y=cauldron->y;
  408.       insert_ob_in_map(tmp,op->map);
  409.       return;
  410.  
  411.   } else if (level<60) {                    /* CREATE MONSTER */
  412.       new_draw_info_format(NDI_UNIQUE,0,op, 
  413.     "The %s %s.",cauldron->name,cauldron_sound());
  414.       remove_contents(cauldron->inv,NULL);
  415.       return;
  416.  
  417.   } else if (level<80) {                    /* MAJOR FIRE */
  418.       remove_contents(cauldron->inv,NULL);
  419.       fire_arch (cauldron, 0, spellarch[SP_L_FIREBALL], SP_L_FIREBALL, 0);
  420.       new_draw_info_format(NDI_UNIQUE,0,op,"The %s erupts in flame!",
  421.         cauldron->name);
  422.       return;
  423.  
  424.   }
  425. /* #endif SPELL_FAILURE_EFFECTS */
  426.     else if (level<100) {                   /* WHAMMY the CAULDRON */
  427.       if(!QUERY_FLAG(cauldron,FLAG_CURSED))
  428.         SET_FLAG(cauldron,FLAG_CURSED);
  429.       else cauldron->magic--;
  430.       cauldron->magic -= RANDOM()%5;
  431.       if(RANDOM()%2) {
  432.         remove_contents(cauldron->inv,NULL);
  433.         new_draw_info_format(NDI_UNIQUE,0,op,
  434.        "Your %s turns darker then makes a gulping sound!",
  435.            cauldron->name);
  436.       } else
  437.         new_draw_info_format(NDI_UNIQUE,0,op,
  438.         "Your %s becomes darker.",cauldron->name);
  439.       return;
  440.  
  441.   }
  442. /* #ifdef SPELL_FAILURE_EFFECTS */ 
  443.     else if (level<110) {                   /* SUMMON EVIL MONSTERS */
  444.       object *tmp=get_random_mon(level/5);
  445.  
  446.       remove_contents(cauldron->inv,NULL);
  447.       if(!tmp) 
  448.     alchemy_failure_effect(op,cauldron,rp,level);
  449.       else if(summon_hostile_monsters(cauldron,RANDOM()%10+1,tmp->arch->name))
  450.        new_draw_info_format(NDI_UNIQUE, 0,op,
  451.         "The %s %s and then pours forth monsters!",
  452.         cauldron->name,cauldron_sound());
  453.       return;
  454.  
  455.   } else if (level<150) {                   /* COMBO EFFECT */
  456.       int roll = RANDOM()%3+1;
  457.       while(roll) {
  458.     alchemy_failure_effect(op,cauldron,rp,level-39);
  459.     roll--;
  460.       }
  461.       return;
  462.   }
  463.  
  464. /* #endif  SPELL_FAILURE_EFFECTS */
  465.     else if (level==151) {                  /* CREATE RANDOM ARTIFACT */
  466.       object *tmp;
  467.     /* this is meant to be better than prior possiblity, 
  468.      * in this one, we allow *any* valid alchemy artifact
  469.        * to be made (rather than only those on the given
  470.      * formulalist) */
  471.       if(!rp) rp=get_random_recipe((recipelist *) NULL);
  472.       if(rp && (tmp=get_archetype(rp->arch_name))) { 
  473.          generate_artifact(tmp,RANDOM()%((op->level/2)+2)+2);
  474.      if((tmp=insert_ob_in_ob(tmp,cauldron))) { 
  475.         remove_contents(cauldron->inv,tmp);
  476.           new_draw_info_format(NDI_UNIQUE, 0,op,
  477.         "The %s %s.",cauldron->name,cauldron_sound());
  478.      }
  479.       }
  480.       return;
  481.   }
  482. /* #ifdef SPELL_FAILURE_EFFECTS */ 
  483.     else if (level<200) {                   /* MANA STORM - watch out!! */
  484.       new_draw_info(NDI_UNIQUE,0,op,"You unwisely release potent forces!");
  485.       remove_contents (cauldron->inv,NULL);
  486.       cast_mana_storm(op,level);
  487.       return;
  488.   }
  489. /* #endif SPELL_FAILURE_EFFECTS */
  490. }
  491.  
  492.  
  493. /* remove_contents() - all but object "save_item" are elimentated from
  494.  * the container list. Note we have to becareful to remove the inventories
  495.  * of objects in the cauldron inventory (ex icecube has stuff in it).  
  496.  */
  497.  
  498. void remove_contents (object *first_ob, object *save_item) {
  499.   object *next,*tmp=first_ob;
  500.  
  501.     while(tmp) {
  502.         next = tmp->below;
  503.         if(tmp==save_item)
  504.           if(!(tmp=next)) break;
  505.           else next=next->below;
  506.      if(tmp->inv) remove_contents(tmp->inv,NULL);
  507.         remove_ob(tmp);
  508.         free_object(tmp);
  509.         tmp=next;
  510.     }
  511. }
  512.  
  513. /* calc_alch_danger() - "Danger" level will determine how bad the backfire
  514.  * could be if the user fails to concoct a recipe properly. Factors include
  515.  * the number of ingredients, the length of the name of each ingredient,
  516.  * the user's effective level, the user's Int and the enchantment on the
  517.  * mixing device (aka "cauldron"). Higher values of 'danger' indicate more
  518.  * danger. -b.t. 
  519.  */
  520.  
  521. int calc_alch_danger(object *caster,object *cauldron) {
  522.    object *item; 
  523.    char name[MAX_BUF];
  524.    int danger=0,nrofi=0; 
  525.  
  526.     /* Higher level, better cauldrons reduce risk */
  527.    danger -= (SK_level(caster)+(cauldron->magic));
  528.  
  529.     /* Higher Int, lower the risk */
  530.    danger -= 3 * (caster->stats.Int - 15);
  531.  
  532.     /* Ingredients. Longer names usually mean rarer stuff.
  533.      * Thus the backfire is worse. Also, more ingredients
  534.      * means we are attempting a more powerfull potion,
  535.      * and thus the backfire will be worse.  */
  536.    for(item=cauldron->inv;item;item=item->below) {
  537.         strcpy(name,item->name);
  538.         if(item->title) sprintf(name,"%s %s",item->name,item->title);
  539.         danger += (strtoint(name)/1000) + 3;
  540.     nrofi++;
  541.    }
  542.    if(nrofi>1) danger *= nrofi;
  543.  
  544.     /* Using a bad device is *majorly* stupid */
  545.    if(QUERY_FLAG(cauldron,FLAG_CURSED)) danger +=80;
  546.    if(QUERY_FLAG(cauldron,FLAG_DAMNED)) danger +=200;
  547.  
  548.    LOG(llevDebug,"calc_alch_danger() returned danger=%d\n",danger);
  549.    return danger;
  550. }
  551.  
  552.